bondscell_results $65151aba-d946-401d-8cca-1874f38146f2queued¤logsrunning¦outputbodysMatrix Multiplication ( * Operator)
We just learned that A .* B is the element-wise product.
So, how is matrix multiplication performed, as in linear algebra?
We use the asterisk (*) operator without the dot.
Problems
Remember that you can get help either through `?` in a REPL or with "Live Docs" right here in Pluto (lower right-hand corner)
5: Array Fusion
Create three 1D vectors, a, b, and c, each of length 4.
Using a single, "fused" broadcast expression, calculate $(a^2 + b)/c$.
Tuple Creation
Like Python, Julia has Tuples. Tuples differ from arrays in two aspects:
A Tuple is immutable. That means that once created the values cannot be changed.
A Tuple is one-dimensional.
A Tuple is non-allocating. Therefore, they have better performance that Arrays.
Tuple Literals
Literal tuples are create by using () (paratheses) whose elements are separated by ',' (commas). For example:
julia> t = (1, 2., "three")
(1, 2.0, "three")
julia> typeof(t)
Tuple{Int64, Float64, String}
NamedTuples
Julia also has a named tuple type. They are basically identical to Tuples, except that the elements can have names or labels by preceeding the value with a character or string and an '=' (equal sign). For example:
julia> n = (a=1, b=2, c="three")
(a = 1, b = 2, c = "three")
There is also a syntatic variation the begins with '(;' (parenthesis - semi-colon).
julia> n = (; a=1, b=2, c="three")
(a = 1, b = 2, c = "three")
Tuples and NamedTuples can also be created using the Tuple and NamedTuple types. See the help documents for details.
Broadcasting ( . Operator)
This is arguably the most important feature for clean, fast code using arrays or tuples.
Arrays
What if you have a vector A = [1, 2, 3] and you want to add 1 to every element? Or what if you want to multiply every element in an array by its corresponding element in another array?
The . operator is a prefix operator that modifies the behavior of other operators such as + and *. It tells Julia to. perform an element-wise operation. The . operator is called the broadcast operator. As we will see in session 1-4, it applies to more than just arrays.
A .+ 1 $\rightarrow$ [2, 3, 4]
A .* B means element-by-element multiplication.
Tuples
The broadcast operator also applies to Tuples. For example:
julia> (1, 2, 3) .+ (4, 5, 6)
(5, 7, 9)
Matrix Protocol
Julia's arrays behave differently from arrays in languages like Python, C, or Java. Julia's design follows the conventions of mathematics and linear algebra, which has two major consequences.
1-Based Indexing
The first element of an array is at index 1.
my_vector[1] is the first element.
my_matrix[1, 1] is the top-left element.
Python and C use 0-based indexing (where my_array[0] is the first element). This 1-based system may be more intuitive for mathematicians and scientists who are used to notation such as $A_{ij}$, where $i$ and $j$ start at 1.
Column-Major Order
This is one secret to Julia's performance. It describes how arrays are physically laid out in your computer's memory.
Row-major order: Elements of a row are grouped together in memory. The computer stores [row1, row2, row3] (e.g., used by NumPy and C)
Column-major order: Elements of a column are grouped together. The computer stores [col1, col2, col3]. (used by e.g., Julia, MATLAB, and FORTRAN)
Why does this matter? Accessing memory that is close together is typically much faster (due to CPU caching) than accessing memory that is spread out.
In Julia, this means that looping down a column, i.e., through the rows, is fast.
julia> for j in 1:numCols
for i in 1:numRows
# Accessing memory sequentially is better, e.g.,
A[i, j] ...
end
end
Note
# character begins a single comment, i.e., the comment string is between the # character and the newline character.
#= and =# is a string block that can span multiple lines.
1: Array Construction
Construct a Vector using an array literal with the values 1, 2, 3.
Construct a 3×3 matrix using an array literal with 1, 2, 3 in the first row.
Construct a 3×3 matrix using an array literal with 1, 2, 3 in the first column.
Construct a 3×3 matrix of interger zeros.
Construct a 3×3 matrix of Float32 ones.
Construct a 3×3 matrix of UInt8 filled with the value 8.
Construct a 3×3×3 array of Float32 whose values are undefined.
Hint: Use Array() and undef.
Note: This array allocates memory, but does not initilize it, saving time.
3: Broadcasting
Construct a 1D vector x containing five evenly spaced points from 0 to $\pi$, inclusive.
Construct a 1D vector y containing five random values between 1 and 10.
Multiply element-wise x and y.
Construct a third 1D vector z containing five values.
Evaluate the expression $x + y * z$
4: Matrix Math vs. Element-wise Math
Create two 2×2 matrices:
Perform matrix multiplication on X and Y.
Perform element-wise multiplication on X and Y.
Are the results the same?
julia> A = [1 2; 3 4]
2×2 Matrix{Int64}:
1 2
3 4
julia> B = [5 6; 7 8]
2×2 Matrix{Int64}:
5 6
7 8
Element-wise multiplication
julia> C = A .* B
2×2 Matrix{Int64}:
5 12
21 32
Matrix multiplication
julia> D = A * B
2×2 Matrix{Int64}:
19 22
43 50
Summary
[...] is the syntax for a literal Array comprehension.
(...) is the syntax for a literal Tuple comprehension.
(...=..., ...=...) is the syntax for a literal NamedTuple comprehension.
.* (dot): broadcast operator, i.e., use for element-wide operations.
* (no dot): matix operator, i,e., use for matrix multiplication.
1-2: Arrays 1
Last Updated: 2 May 2026
Array Creation
Functions
You can create arrays with functions like zeros(2, 3) or rand(3, 3), where the integers in parentheses specify the dimensions.
Array Literals
For literal arrays, we use [] with two simple rules:
Commas (,) signify a 1D column Vector.
Spaces ( ) signify a 1D row Vector or a 1×N Matrix.
julia> x = [1., 2., 3.]
3-element Vector{Float64}:
1.0
2.0
3.0
julia> y = [1. 2. 3.]
1×3 Matrix{Float64}:
1.0 2.0 3.0
Semicolon Syntax
Semicolons (;) separate rows.
The four following examples show array creation:
1: A 1D Vector (using commas) produces a 3-element Vector{Int64}:
julia> v = [1, 2, 3]
3-element Vector{Int64}:
1
2
3
2: A 2D Matrix (using spaces for columns and semicolons for rows) produces a 2×3 Matrix{Int64}:
julia> m = [1 2 3; 4 5 6]
2×3 Matrix{Int64}:
1 2 3
4 5 6
A 1x3 Row Vector (Matrix) produces a 1×3 Matrix{Int64}:
julia> row_vec = [1 2 3]
1×3 Matrix{Int64}:
1 2 3
A 3x1 Column Vector (Matrix) produces a 3×1 Matrix{Int64}:
julia> col_vec = [1; 2; 3]
3-element Vector{Int64}:
1
2
3
[1, 2, 3], with commas, gives a 1D Vector, while [1; 2; 3], with semicolons, gives a 2D, 3×1 Matrix. The 1D Vector is "dimensionless" and often acts like a column vector in math operations, which is very convenient.
Array Elements
Array elements do not need to be homogeneous. They can be heterogeneous, meaning that they can have any type. For example:
julia> a = [1, 2f0, "three", :four, nothing, missing]
4-element Vector{Any}:
1
2.0f0
"three"
:four
nothing
missing
Note
The nothing value is of type Nothing and is synonymous with Python's none object. The missing value is of type Missing and means that the value is missing. Statistical functions will ignore the missing value during computations, unlike the nothing value, so the results will be statistically correct.
2: Tuples and NamedTuples
Construct a Tuple literal x of three integers.
Construct a Tuple literal y of three floats.
Multiply x times y.
Construct a Tuple literal containing an integer, a float, and a string.
Construct a NamedTuple literal with labels a, b, and c and integer, float, and string values.
Multidimensional Arrays
In Julia, an array is a collection of objects stored in a multi-dimensional grid.
A 1D array is a Vector, i.e., as a single list or column of numbers.
A 2D array is a Matrix, i.e., rows and columns.
A 3D array is a cube of numbers, but of course one can keep going to 4D, 5D, or any number of dimensions.
We interact with these using square brackets [] for indexing, e.g., A[2] gets the second element of a vector. M[2, 3] gets the element at the second row, third column of a matrix.
Array Fusion
This is where the magic happens and the power of Juila. What happens if you chain multiple "dotted" operations?
julia> A = rand(1000)
julia> B = rand(1000)
julia> C = rand(1000)
julia> D = A .* B .+ C
Let's compare how Python (sp., Numpy) and Julia compare.
In Python: D = A * B + C
Python first calculates T = A * B, where T is a temporary array to store the result of the multiplication.
It then calculates the final array D = T + C.
This took two passes over the data and allocated a temporary array T of N-elements, which is then discarded. Allocating memory, especially large amounts of memory (say ~ GBs) signifantly impacts performance and may result in the calculation returning an "Out of memory" error.
In Julia: D = A .* B .+ C
Julia sees the "chain of dots" and performs loop fusion.
It knows you want to do D[i] = A[i] * B[i] + C[i] for every element.
It compiles this down to a single, performant for-loop that elimanates the need for the temporary array T.
The above array expression is effectively:
julia> # This is what Julia effectively runs:
julia> D = similar(A) # Allocate D *once*
julia> for i in 1:length(A)
D[i] = A[i] * B[i] + C[i]
end
Note
In Julia, the array expression can also benefit from vectorization or single-instruction-multiple-data (SIMD), where a single operation is simultaneously applied to multiple data. This will be discussed in more detail in session 2-4: Parallel-Computating. It can also benefit from vector pipelining, where the multiply and add operations are performed simultaneously and in succession. That is, the multiplication operation is performed first on multiple values and the result is followed by the addition operation on multiple values. While the addition operation is being performed, the next multiplication operation is done, resulting in a multiplication-addition pipeline.